package com.headStorm.java8;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.io.checksum.CRC16;
import cn.hutool.core.util.HexUtil;
import cn.hutool.extra.spring.SpringUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONUtil;
import org.junit.jupiter.api.Test;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Lamda 表达式语法:
 * java8中引入一个新的操作符号 -> 该操作符
 * 左侧: Lamda 表达式的参数列表
 * 右侧: Lamda 表达式所执行的功能,即lamda体
 *
 * 语法格式一:无参数,无返回值。
 *      () -> System.out.println("helloWorld");
 *
 * 有一个参数,并且有返回值。
 *      (x) -> System.out.println(x)
 *
 *  当只有一个参数,小括号可以省略不写。
 *      x -> System.out.println(x)
 *
 *  当有两个参数的时候,并且lamda中有多条语句执行时候，并且有返回值的时候
 *   Comparator<Integer> comparator = (x,y) ->{
 *             System.out.println();
 *             return Integer.compare(x,y) ;
 *         };
 *
 *  当只有一条返回语句的时候 大括号和return都可以省略
 *
 * 二 Lamda表达式需要函数式接口的支持
 * 函数式接口：接口中只有一个抽象方法的接口称作函数式接口
 */
public class LamdaDemo {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
        System.out.println(list.size());

        JSONArray objects = JSONUtil.parseArray("");
    }

    @Test
    public void test1() {
        //jdk1.7之前必须是final
        int num = 0;
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(num);
            }
        };
        Runnable runnable1 = () -> System.out.println(num);
        runnable1.run();
    }

    @Test
    public void test2() {
        Consumer<String> consumer = (x) -> System.out.println(x);
        consumer.accept("helloworld");
    }

    @Test
    public void test3() {
        Comparator<Integer> comparator = (x, y) -> {
            System.out.println();
            return Integer.compare(x, y);
        };
    }

    @Test
    public void test4() {
        Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
    }

    //需求:对一个数来进行计算
    @Test
    public void test6() {
        Integer operation = operation(6, x -> x * x);
        System.out.println(operation);
    }

    public Integer operation(Integer num, MyFun mf) {
        return mf.getValue(num);
    }

    @Test
    public void test5(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        list.stream().filter(num -> num > 5).collect(Collectors.toSet()).forEach(o -> System.out.println(o));
    }

    @Test
    public void test7() throws IOException {
//        CRC16 crc16 = new CRC16();
//        System.out.println(crc16.getValue());



        byte[] bytes = HexUtil.decodeHex("00 01");
//        System.out.println(bytes.length);
//        for (byte aByte : bytes) {
//            System.out.println(aByte);
//        }
        CRC16 crc16 = new CRC16();
        crc16.update(bytes,0 ,bytes.length);
        System.out.println(crc16.getValue());

        //先写进去
        long n = 1000000L;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
        dos.write((int) n);
//再读出来
        byte[] buf = baos.toByteArray();
        System.out.println(buf[0]);
    }

    public static String crc16(String gprsstr) {
        try {
            int crc;
            int strlength, r;
            byte sbit;
            int tc;
            strlength = gprsstr.length();
           
            //byte[] data = gprsstr.getBytes();
            byte[] data = HexUtil.decodeHex(gprsstr);
            System.out.println(data.length);
            crc = 0x0000FFFF;
            for (int i = 0; i < strlength; i++) {
                tc = (int) (crc >>> 8);
                crc = (int) (tc ^ data[i]);
                for (r = 0; r < 8; r++) {
                    sbit = (byte) (crc & 0x00000001);
                    crc >>>= 1;
                    if (sbit != 0)
                        crc ^= 0x0000A001;
                }
            }
            return Integer.toHexString(crc);
        } catch (Exception ex) {
            return "";
        }
    }

    @Test
    public void test8(){
        System.out.println(crc16("7E 0F 00 0A 0C 00 00 00 00 01 11 FF 02"));
    }
    

}
